package com.hgx.su.common.pure.log.util;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;

@SuppressWarnings("all")
public class DateUtil {
    private static final Logger logger = LoggerFactory.getLogger(DateUtil.class);

    /**
     * value = yyyy-MM-dd HH:mm:ss
     */
    public static final String TIMESTAMP_FORMAT = "yyyy-MM-dd HH:mm:ss.SSS";
    /**
     * value = yyyy-MM-dd HH:mm:ss
     */
    public static final String FULL_STAND_FORMAT = "yyyy-MM-dd HH:mm:ss";

    /**
     * value = yyyy/MM/dd HH:mm:ss
     */
    public static final String FULL_STAND_FORMAT_2 = "yyyy/MM/dd HH:mm:ss";
    /**
     * value = yyyyMMddHHmmss
     */
    public static final String FULL_SPECIAL_FORMAT = "yyyyMMddHHmmss";
    /**
     * value = yyyyMMdd HH:mm:ss
     */
    public static final String FULL_SPECIAL_FORMAT2 = "yyyyMMdd HH:mm:ss";
    /**
     * value = yy-MM-dd HH:mm"
     */
    public static final String SIMPLE_STAND_FORMAT = "yy-MM-dd HH:mm";
    /**
     * value = yyyy-MM-dd HH:mm
     */
    public static final String FULL_DATE_SIMPLE_TIME = "yyyy-MM-dd HH:mm";

    /**
     * value = yyyy-MM-dd
     */
    public static final String SIMPLE_STAND_DATE = "yyyy-MM-dd";
    /**
     * value = HH:mm:ss
     */
    public static final String FULL_TIME = "HH:mm:ss";

    /**
     * value = yyyyMMdd
     */
    public static final String SIMPLE_STAND_DATE2 = "yyyyMMdd";

    /**
     * value = yyyy_MM_dd
     */
    public static final String SIMPLE_STAND_DATE3 = "yyyy_MM_dd";

    /**
     * value = yyyy/MM/dd
     */
    public static final String SIMPLE_STAND_DATE4 = "yyyy/MM/dd";
    /**
     * value = HH:mm
     */
    public static final String FULL_SIMPLE_TIME = "HH:mm";

    public static String getCurrentDate(String pattern) {
        return dateFormat(new Date(), pattern);
    }

    public static Date getCurrentDate() {
        return new Date();
    }

    /**
     * return format yyyy-MM-dd HH:mm:ss
     *
     * @param date
     * @return
     */
    public static String dateFormat(Date date) {
        return dateFormat(date, FULL_STAND_FORMAT);
    }

    public static String dateFormat(Date date, String pattern) {
        if (null == date) {
            return null;
        }
        SimpleDateFormat sdf = new SimpleDateFormat(pattern);
        String result = sdf.format(date);
        return result;
    }

    public static Date intConvertDate(int year, int month, int day, int hour, int minute, int second) {
        Calendar ca = Calendar.getInstance();
        ca.set(year, month-1, day, hour, minute, second);
        return ca.getTime();
    }

    public static Date strConvertDate(String str) throws ParseException {
        DateFormat df = DateFormat.getDateInstance();
        return df.parse(str);
    }

    public static Date strConvertDate(String str, String pattern) throws ParseException {
        // DateFormat df = DateFormat.getDateInstance();
        SimpleDateFormat sdf = new SimpleDateFormat(pattern);
        return sdf.parse(str);
    }

    public static Calendar strConverCalendar(String source) throws ParseException {
        SimpleDateFormat df = new SimpleDateFormat(FULL_SPECIAL_FORMAT);
        df.parse(source);
        return df.getCalendar();
    }

    public static Calendar strConverCalendar(String source, String pattern) throws ParseException {
        SimpleDateFormat df = new SimpleDateFormat(pattern);
        df.parse(source);
        return df.getCalendar();
    }

    public static Calendar dateConverCalendar(Date d) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(d);
        return cal;
    }

    /**
     * 在日期上加上一定的秒数
     *
     * @param date    日期
     * @param seconds 需要增加的秒数, 如果为负数，表示减去多少秒
     * @return
     */
    public static Date dateAddSeconds(Date date, int seconds) {
        return new Date(date.getTime() + ((long) seconds * 1000));
    }

    /**
     * 在日期上加上一定的分钟
     *
     * @param date    日期
     * @param minutes 需要增加的分钟数, 如果为负数，表示减去多少分钟
     * @return
     */
    public static Date dateAddMinutes(Date date, int minutes) {
        return new Date(date.getTime() + ((long) minutes * 60 * 1000));
    }

    /**
     * 在日期上加上一定的小时
     *
     * @param date  日期
     * @param hours 需要增加的小时数, 如果为负数，表示减去多少小时
     * @return
     */
    public static Date dateAddHours(Date date, int hours) {
        return new Date(date.getTime() + ((long) hours * 60 * 60 * 1000));
    }

    /**
     * 在日期上加上一定的天数
     *
     * @param date 日期
     * @param days 需要增加的天数, 如果为负数，表示减去多少天
     * @return
     */
    public static Date dateAddDays(Date date, int days) {
        return new Date(date.getTime() + ((long) days * 24 * 60 * 60 * 1000));
    }

    /**
     * 在日期上加上一定的月数
     *
     * @param date   日期
     * @param months 需要增加的月数，如果为负数，表示减去多少月
     * @return
     */
    public static Date dateAddMonths(Date date, int months) {
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        c.add(Calendar.MONTH, months);
        return c.getTime();
    }

    /**
     * 获取当前时间戳
     *
     * @return
     */
    public static Long getTimeMillis() {
        return System.currentTimeMillis();
    }

    /**
     * 将时间段分割成每一天
     *
     * @param startDate
     * @param endDate
     * @return
     * @throws Exception
     */
    public static List<Date> dateSplit(Date startDate, Date endDate) throws Exception {
        if (startDate.compareTo(endDate) > 0)
            throw new Exception("结束时间应该在开始时间之后");

        Long msec = endDate.getTime() - startDate.getTime(); // 相差毫秒数
        Long days = msec / 1000 / 60 / 60 / 24; // 相差天数

        List<Date> dateList = new ArrayList<Date>();
        for (int i = 0; i <= days; i++) {
            Long temp = (long) i * (24 * 60 * 60 * 1000);
            dateList.add(new Date(endDate.getTime() - temp));
        }
        return dateList;
    }

    /**
     * 获取昨天的日期
     *
     * @param pattern 日期格式
     * @return
     */
    public static String yesterday(String pattern) {
        Date date = dateAddDays(new Date(), -1);
        return dateFormat(date, pattern);
    }

    /**
     * 判断日期是否为今天
     *
     * @param str 需要比较的日期
     * @return true 参与比较的日期是今天的日期 false 参与比较的日期不是今天的日期
     * @throws ParseException
     */
    public static boolean isToday(String str) throws ParseException {
        Date date = strConvertDate(str, SIMPLE_STAND_DATE);
        Date today = strConvertDate(dateFormat(new Date(), SIMPLE_STAND_DATE), SIMPLE_STAND_DATE);
        return date.equals(today);
    }

    /**
     * 字符串两个日期的比较工具类
     *
     * @param date1
     * @param date2
     * @return
     * @author zhouzhigang
     * @date 2016年4月22日
     */
    public static int compare_date(String date1, String date2) {

        DateFormat df = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        try {
            Date dt1 = df.parse(date1);
            Date dt2 = df.parse(date2);
            if (dt1.getTime() > dt2.getTime()) {
                // date1 在 date2前
                return 1;
            } else if (dt1.getTime() < dt2.getTime()) {
                // date1 在 date2后
                return -1;
            } else {
                // date1 和 date2相等
                return 0;
            }
        } catch (Exception e) {
            logger.error("两个字符串日期类型的数据比较发生异常", e);
        }
        return 0;
    }

    public static int compare_date(String date1, String date2, String pattern) {

        DateFormat df = new SimpleDateFormat(pattern);
        try {
            Date dt1 = df.parse(date1);
            Date dt2 = df.parse(date2);
            return compareDate(dt1, dt2);
        } catch (Exception e) {
            logger.error("两个字符串日期类型的数据比较发生异常", e);
        }
        return 0;
    }

    /**
     * 字符串两个日期的比较工具类
     *
     * @param dt1 日期1
     * @param dt2 日期2
     * @return 日期1大则返回1 日期2大则返回-1 相等返回0
     */
    public static int compareDate(Date dt1, Date dt2) {
        try {
            return Long.compare(dt1.getTime(), dt2.getTime());
        } catch (Exception e) {
            logger.error("两个日期类型的数据比较发生异常", e);
        }
        return 0;
    }

    /**
     * 计算两个时间相差的分钟数
     *
     * @param beginTime 开始时间
     * @param endTime   结束时间
     * @return
     * @author liuj
     * @date 2016年6月2日
     */
    public static int differMinutes(Date beginTime, Date endTime) {
        long millisecond = endTime.getTime() - beginTime.getTime();
        int minutes = (int) (millisecond / 1000 / 60);
        return minutes;
    }

    /**
     * 判断当前时间是否在两个时间点之间
     *
     * @param start MM:SS
     * @param end   MM:SS
     * @return
     * @throws ParseException
     */
    public static boolean between(String start, String end) throws ParseException {
        Date now = new Date();
        String day = DateUtil.getCurrentDate(DateUtil.SIMPLE_STAND_DATE);
        String startTime = day + " " + start;
        if (end.compareTo(start) < 0) {
            end = String.format("%d%s", Integer.parseInt(end.substring(0, 2)) + 12, end.substring(2));
            day = DateUtil.dateFormat(DateUtil.dateAddDays(now, 1), DateUtil.SIMPLE_STAND_DATE);
        }
        String endTime = day + " " + end;
        Date startDate = DateUtil.strConvertDate(startTime, DateUtil.FULL_DATE_SIMPLE_TIME);
        Date endDate = DateUtil.strConvertDate(endTime, DateUtil.FULL_DATE_SIMPLE_TIME);
        return now.after(startDate) && now.before(endDate);
    }

    /**
     * 判断当前日期是否在两个时间点之间
     *
     * @param start 开始日期
     * @param end   结束日期
     * @return
     * @throws ParseException
     * @author liuj
     * @date 2016年12月9日
     */
    public static boolean between(Date start, Date end) throws ParseException {
        Date now = new Date();
        // 判断当前时间是否大于开始时间
        if (null != start) {
            if (compareDate(now, start) < 0) {
                return false;
            }
        }

        // 判断当前时间是否小于结束时间
        if (null != end) {
            if (compareDate(now, end) >= 0) {
                return false;
            }
        }
        return true;
    }
}
